package cn.com.thinker.tools.time;

import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.regex.Pattern;

//import org.apache.commons.lang3.time.DateFormatUtils;

/**
 * @desc:时间处理工具类
 * 
 */
public class DateExtUtils extends DateUtils{
	
	private static final String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
	
	// 格式：年－月－日 小时：分钟：秒
		public static final String COMMON_DATETIME = "yyyy-MM-dd HH:mm:ss";

		// 格式：年－月－日
		public static final String LONG_DATE = "yyyy-MM-dd";

		// 格式：月－日
		public static final String SHORT_DATE = "MM-dd";

		// 格式：年-月
		public static final String YEAR_MONTH = "yyyy-MM";

		// 格式：小时：分钟：秒
		public static final String LONG_TIME = "HH:mm:ss";
		
		private static final String DEFAULT_DATE_FORMAT = COMMON_DATETIME;

		public static final String WeekNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };

		/**
		 * 简单的日期格式校验(yyyy-MM-dd)
		 * 
		 * @param date
		 *            输入日期
		 * @return 有效返回true, 反之false
		 */
		public static Boolean isValidDate(String date) {
			return isValidDate(date, "\\d{4}-\\d{2}-\\d{2}");
		}

		/**
		 * 简单的日期格式校验(yyyy-MM-dd)
		 * 
		 * @param date
		 *            输入日期
		 * @param pattern
		 *            日期格式
		 * @return 有效返回true, 反之false
		 */
		public static Boolean isValidDate(String date, String pattern) {
			return StringUtils.isNotBlank(date) && Pattern.compile(pattern).matcher(date).matches();
		}

		/**
		 * 获取当前日期对象
		 * 
		 * @return 当前日期对象
		 */
		public static Date now() {
			return new Date();
		}

		/**
		 * 获取当前日期字符串
		 * 
		 * @param format
		 *            日期格式
		 * @return 当前日期字符串
		 */
		public static String now(String format) {
			return format(now(), format);
		}

		/**
		 * 转换日期字符串为日期对象(默认格式: yyyy-MM-dd HH:mm:ss)
		 * 
		 * @param dateStr
		 *            日期字符串
		 * @return 日期对象
		 */
		public static Date toDate(String dateStr) {
			return toDate(dateStr, DEFAULT_DATE_FORMAT);
		}

		/**
		 * 转换日期即字符串为Date对象
		 * 
		 * @param dateStr
		 *            日期字符串
		 * @param pattern
		 *            日期格式
		 * @return 日期对象
		 */
		public static Date toDate(String dateStr, String pattern) {
			return DateTimeFormat.forPattern(pattern).parseDateTime(dateStr).toDate();
		}

		/**
		 * 生成时间
		 * 
		 * @param millis
		 *            毫秒
		 * @return 日期
		 */
		public static Date toDate(long millis) {
			return new DateTime(millis).toDate();
		}

		/**
		 * 格式化日期对象
		 * 
		 * @param date
		 *            日期对象
		 * @param format
		 *            日期格式
		 * @return 当前日期字符串
		 */
		public static String format(Date date, String format) {
			return new DateTime(date).toString(format);
		}

		/**
		 * 格式化日期对象，格式为yyyy-MM-dd HH:mm:ss
		 * 
		 * @param date
		 *            日期对象
		 * @return 日期字符串
		 */
		public static String format(Date date) {
			return new DateTime(date).toString(DEFAULT_DATE_FORMAT);
		}

		/**
		 * 格式化日期对象，格式为yyyy-MM-dd HH:mm:ss
		 * 
		 * @param mills
		 *            毫秒
		 * @return 日期字符串
		 */
		public static String format(Long mills) {
			return new DateTime(mills).toString(DEFAULT_DATE_FORMAT);
		}

		/**
		 * 格式化日期对象
		 * 
		 * @param mills
		 *            毫秒
		 * @param pattern
		 *            格式
		 * @return 日期字符串
		 */
		public static String format(Long mills, String pattern) {
			return new DateTime(mills).toString(pattern);
		}

		/**
		 * 计算两个日期的时间差（单位：秒）
		 *
		 * @param startTime
		 *            开始时间
		 * @param endTime
		 *            结束时间
		 * @return 时间间隔
		 */
		public static long timeInterval(Date startTime, Date endTime) {
			long start = startTime.getTime();
			long end = endTime.getTime();
			return (end - start) / 1000;
		}

		/**
		 * 获取指定日期当天的开始时间
		 * 
		 * @param date
		 *            日期
		 * @return 时间
		 */
		public static Date startOfDay(Date date) {
			return new DateTime(date).withTimeAtStartOfDay().toDate();
		}

		/**
		 * 获取指定日期当天的结束时间
		 * 
		 * @param date
		 *            日期
		 * @return 时间
		 */
		public static Date endOfDay(Date date) {
			return new DateTime(date).millisOfDay().withMaximumValue().toDate();
		}

		/**
		 * 获取本周周几的日期对象
		 * 
		 * @param day
		 *            1:星期一，2:星期二，...
		 * @return 本周周几的日期对象
		 */
		public static Date dayOfWeek(Integer day) {
			return new DateTime(DateTime.now().toString("yyyy-MM-dd")).withDayOfWeek(day).toDate();
		}

		/**
		 * 获取本月第几天日期对象
		 * 
		 * @param day
		 *            1:第一天，2:第二天，...
		 * @return 本月第几天日期对象
		 */
		public static Date dayOfMonth(Integer day) {
			return new DateTime(DateTime.now().toString("yyyy-MM-dd")).withDayOfMonth(day).toDate();
		}

		/**
		 * 获取本年第几天日期对象
		 * 
		 * @param day
		 *            1:第一天，2:第二天，...
		 * @return 本年第几天日期对象
		 */
		public static Date dayOfYear(Integer day) {
			return new DateTime(DateTime.now().toString("yyyy-MM-dd")).withDayOfYear(day).toDate();
		}

		/**
		 * 增加分钟
		 * 
		 * @param date
		 *            时间
		 * @param numOfMinutes
		 *            分钟数
		 * @return 时间
		 */
		public static Date addMinutes(Date date, int numOfMinutes) {
			return new DateTime(date).plusMinutes(numOfMinutes).toDate();
		}

		/**
		 * 增加小时
		 * 
		 * @param date
		 *            时间
		 * @param numOfHours
		 *            小时数
		 * @return 时间
		 */
		public static Date addHours(Date date, int numOfHours) {
			return new DateTime(date).plusHours(numOfHours).toDate();
		}

		/**
		 * 增加天数
		 * 
		 * @param date
		 *            时间
		 * @param numdays
		 *            天数
		 * @return 时间
		 */
		public static Date addDays(Date date, int numdays) {
			return new DateTime(date).plusDays(numdays).toDate();
		}

		/**
		 * 增加周
		 * 
		 * @param date
		 *            时间
		 * @param numWeeks
		 *            周数
		 * @return 时间
		 */
		public static Date addWeeks(Date date, int numWeeks) {
			return new DateTime(date).plusWeeks(numWeeks).toDate();
		}

		/**
		 * 增加月份
		 * 
		 * @param date
		 *            时间
		 * @param numMonths
		 *            月数
		 * @return 时间
		 */
		public static Date addMonths(Date date, int numMonths) {
			return new DateTime(date).plusMonths(numMonths).toDate();
		}

		/**
		 * 增加年
		 * 
		 * @param date
		 *            时间
		 * @param numYears
		 *            年数
		 * @return 时间
		 */
		public static Date addYears(Date date, int numYears) {
			return new DateTime(date).plusYears(numYears).toDate();
		}
		
		/**
		 * 日期a是否大于日期b
		 * 
		 * @param a
		 *            日期a
		 * @param b
		 *            日期b
		 * @return 大于返回true，反之false
		 */
		public static Boolean isAfter(Date a, Date b) {
			return new DateTime(a).isAfter(b.getTime());
		}

		/**
		 * 日期a是否大于当前日期
		 * 
		 * @param a
		 *            日期a
		 * @return 大于返回true，反之false
		 */
		public static Boolean isAfterNow(Date a) {
			return new DateTime(a).isAfterNow();
		}

		/**
		 * 日期a是否小于日期b
		 * 
		 * @param a
		 *            日期a
		 * @param b
		 *            日期b
		 * @return 小于返回true，反之false
		 */
		public static Boolean isBefore(Date a, Date b) {
			return new DateTime(a).isBefore(b.getTime());
		}

		/**
		 * 日期a是否大于当前日期
		 * 
		 * @param a
		 *            日期a
		 * @return 小于返回true，反之false
		 */
		public static Boolean isBefore(Date a) {
			return new DateTime(a).isBeforeNow();
		}

		/**
		 * 获得当前月的第一天
		 * 
		 * @param date
		 *            日期
		 * @return 当前月的第一天
		 */
		public static Date startDateOfMonth(Date date) {
			DateTime dateTime = new DateTime(date);
			return dateTime.dayOfMonth().withMinimumValue().toDate();
		}

		/**
		 * 获得当前月的最后一天
		 * 
		 * @param date
		 *            日期
		 * @return 当前月的最后一天
		 */
		public static Date endDateOfMonth(Date date) {
			DateTime dateTime = new DateTime(date);
			return dateTime.dayOfMonth().withMaximumValue().toDate();
		}

		/**
		 * 获得当前周第一天,周一
		 * 
		 * @param date
		 *            日期
		 * @return 当前周第一天
		 */
		public static Date startDateOfWeek(Date date) {
			DateTime dateTime = new DateTime(date);
			return dateTime.dayOfWeek().withMinimumValue().toDate();
		}

		/**
		 * 获得当前周最后一天 周日
		 * 
		 * @param date
		 *            日期
		 * @return 当前周最后一天
		 */
		public static Date endDateOfWeek(Date date) {
			DateTime dateTime = new DateTime(date);
			return dateTime.dayOfWeek().withMaximumValue().toDate();
		}

		/**
		 * 以友好的方式显示当前时间与传入时间的时间差
		 * 
		 * @param time
		 * @return
		 */
		public static String friendlyTimeToNow(Date time) {
			if (time == null)
				return "unknown";
			int ct = (int) ((System.currentTimeMillis() - time.getTime()) / 1000);
			if (ct < 3600)
				return Math.max(ct / 60, 1) + "分钟前";
			if (ct >= 3600 && ct < 86400)
				return ct / 3600 + "小时后";
			if (ct >= 86400 && ct < 2592000) { // 86400 * 30
				int day = ct / 86400;
				return (day > 1) ? "天前" : "昨天";
			}
			if (ct >= 2592000 && ct < 31104000) // 86400 * 30
				return ct / 2592000 + "个月前";
			return ct / 31104000 + "年前";
		}
		
		
		/**
		 * 把符合日期格式的字符串转换为日期类型
		 * 
		 * @param dateStr
		 * @return
		 */
		public static Date string2Date(String dateStr, String format) {
			Date d = null;
			SimpleDateFormat formater = new SimpleDateFormat(format);
			try {
				formater.setLenient(false);// 严格解析
				d = formater.parse(dateStr);
			} catch (Exception e) {
				d = null;
			} finally {
				formater = null;
			}
			return d;
		}

		/**
		 * 把符合日期格式的字符串转换为日期类型
		 */
		public static Date string2Date(String dateStr, String format,
				ParsePosition pos) {
			Date d = null;
			SimpleDateFormat formater = new SimpleDateFormat(format);
			try {
				formater.setLenient(false);
				d = formater.parse(dateStr, pos);
			} catch (Exception e) {
				d = null;
			} finally {
				formater = null;
			}
			return d;
		}

		/**
		 * 把日期转换为字符串
		 * 
		 * @param date
		 * @return
		 */
		public static String date2String(Date date, String format) {
			if(date == null){
				return "";
			}
			String result = "";
			SimpleDateFormat formater = new SimpleDateFormat(format);
			try {
				result = formater.format(date);
			} catch (Exception e) {
				result = "";
			} finally {
				formater = null;
			}
			return result;
		}
		
		public static boolean isToday(Date this_login_time) {
			String currDateStr = date2String(new Date(), "yyyyMMdd");
			String paramDateStr = date2String(this_login_time, "yyyyMMdd");
			return currDateStr.equals(paramDateStr);
		}

		/**
		 * 获取当前时间的指定格式
		 * 
		 * @param format
		 * @return
		 */
		public static String getCurrDate(String format) {
			return date2String(new Date(), format);
		}

		/**
		 * 获取当前的日期(yyyy-MM-dd)
		 */
		public static String getCurrDate() {
			return date2String(new Date(), LONG_DATE);
		}

		public static String getCurrWeek() {
			int i = Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
			return WeekNames[i - 1];
		}

		/**
		 * 获得当前日期,如7月13号就返回13
		 * 
		 * @return
		 */
		public static int getCurrDay() {
			Calendar calendar = Calendar.getInstance();
			return calendar.get(Calendar.DATE);
		}

		/**
		 * 获得当前月份
		 * 
		 * @return
		 */
		public static int getCurrMonth() {
			Calendar calendar = Calendar.getInstance();
			return calendar.get(Calendar.MONTH) + 1;
		}

		/**
		 * 获得当前年份
		 * 
		 * @return
		 */
		public static int getCurrYear() {
			Calendar calendar = Calendar.getInstance();
			return calendar.get(Calendar.YEAR);
		}

		/**
		 * 返回日期的天，即yyyy-MM-dd中的dd
		 * 
		 * @param date
		 * @return
		 */
		public static int getDay(Date date) {
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			return calendar.get(Calendar.DATE);
		}

		/**
		 * 返回日期的月份，1-12,即yyyy-MM-dd中的MM
		 * 
		 * @param date
		 * @return
		 */
		public static int getMonth(Date date) {
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			return calendar.get(Calendar.MONTH) + 1;
		}

		/**
		 * 返回日期的年,即yyyy-MM-dd中的yyyy
		 * 
		 * @param date
		 *            Date
		 * @return int
		 */
		public static int getYear(Date date) {
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			return calendar.get(Calendar.YEAR);
		}

		/**
		 * 为日期增减时间,如: DateUtil.dateSub(Calendar.HOUR,"1999-9-9 15:16:36",3)
		 * 
		 * @param dateStr
		 * @param amount
		 * @return
		 */
		public static String dateChange(int dateKind, String dateStr, int amount) {
			Date date = string2Date(dateStr, COMMON_DATETIME);
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			calendar.add(dateKind, amount);
			return date2String(calendar.getTime(), COMMON_DATETIME);
		}

		/**
		 * 两个日期相减得到秒数
		 * 
		 * @param smallTime
		 * @param bigTime
		 * @return 相减得到的秒数
		 */
		public static long timeSub(String smallTime, String bigTime) {
			long first = string2Date(smallTime, COMMON_DATETIME).getTime();
			long second = string2Date(bigTime, COMMON_DATETIME).getTime();
			return (second - first) / 1000;
		}

		/**
		 * 获得某月的天数
		 * 
		 * @param year
		 *            年份
		 * @param month
		 *            月份[1-12]
		 * @return 天数
		 */
		public static int getDaysOfMonth(String year, String month) {
			int days = 0;
			if (month.equals("1") || month.equals("3") || month.equals("5")
					|| month.equals("7") || month.equals("8") || month.equals("10")
					|| month.equals("12")) {
				days = 31;
			} else if (month.equals("4") || month.equals("6") || month.equals("9")
					|| month.equals("11")) {
				days = 30;
			} else {
				if ((Integer.parseInt(year) % 4 == 0 && Integer.parseInt(year) % 100 != 0)
						|| Integer.parseInt(year) % 400 == 0) {
					days = 29;
				} else {
					days = 28;
				}
			}
			return days;
		}

		/**
		 * 获取某年某月的天数
		 * 
		 * @param year
		 *            年份
		 * @param month
		 *            月份[1-12]
		 * @return 天数
		 */
		public static int getDaysOfMonth(int year, int month) {
			Calendar calendar = Calendar.getInstance();
			calendar.set(year, month - 1, 1);
			return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
		}

		/**
		 * 计算两个日期相差的天数，如果date2 > date1 返回正数，否则返回负数
		 * 
		 * @param date1
		 *            Date
		 * @param date2
		 *            Date
		 * @return long
		 */
		public static long dayDiff(Date date1, Date date2) {
			return (date2.getTime() - date1.getTime()) / 86400000;
		}

		/**
		 * 比较两个日期的年差
		 * 
		 * @param before
		 *            格式：yyyy-MM-dd
		 * @param after
		 *            格式：yyyy-MM-dd
		 * @return
		 */
		public static int yearDiff(String before, String after) {
			Date beforeDay = string2Date(before, LONG_DATE);
			Date afterDay = string2Date(after, LONG_DATE);
			return getYear(afterDay) - getYear(beforeDay);
		}

		/**
		 * 当前日期减去after所指定的日期得到的年份
		 * 
		 * @param after
		 *            格式：yyyy-MM-dd
		 * @return
		 */
		public static int yearDiffCurr(String after) {
			Date beforeDay = new Date();
			Date afterDay = string2Date(after, LONG_DATE);
			return getYear(beforeDay) - getYear(afterDay);
		}

		/**
		 * 比较当前日期与指定日期的差
		 * 
		 * @param before
		 *            格式：yyyy-MM-dd
		 * @return
		 */
		public static long dayDiffCurr(String before) {
			Date currDate = string2Date(getCurrDate(), LONG_DATE);
			Date beforeDate = string2Date(before, LONG_DATE);
			return (currDate.getTime() - beforeDate.getTime()) / 86400000;

		}

		/**
		 * 获得当前日期字符串，格式"yyyy-MM-dd HH:mm:ss"
		 * 
		 * @return
		 */
		public static String getNow() {
			Calendar today = Calendar.getInstance();
			return date2String(today.getTime(), COMMON_DATETIME);
		}

		/**
		 * 根据生日获取星座
		 * 
		 * @param birth
		 *            格式：YYYY-mm-dd
		 * @return
		 */
		public static String getConstellation(String birth) {
			if (!isDate(birth)) {
				birth = "2000" + birth;
			}
			if (!isDate(birth)) {
				return "";
			}
			int month = Integer.parseInt(birth.substring(birth.indexOf("-") + 1,
					birth.lastIndexOf("-")));
			int day = Integer.parseInt(birth.substring(birth.lastIndexOf("-") + 1));
			String s = "魔羯水瓶双鱼牡羊金牛双子巨蟹狮子处女天秤天蝎射手魔羯";
			int[] arr = { 20, 19, 21, 21, 21, 22, 23, 23, 23, 23, 22, 22 };
			int start = month * 2 - (day < arr[month - 1] ? 2 : 0);
			return s.substring(start, start + 2) + "座";
		}

		/**
		 * 判断日期是否有效,包括闰年的情况
		 * 
		 * @param date
		 *            格式：YYYY-mm-dd
		 * @return
		 */
		public static boolean isDate(String date) {
			StringBuffer reg = new StringBuffer(
					"^((\\d{2}(([02468][048])|([13579][26]))-?((((0?");
			reg.append("[13578])|(1[02]))-?((0?[1-9])|([1-2][0-9])|(3[01])))");
			reg.append("|(((0?[469])|(11))-?((0?[1-9])|([1-2][0-9])|(30)))|");
			reg.append("(0?2-?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][12");
			reg.append("35679])|([13579][01345789]))-?((((0?[13578])|(1[02]))");
			reg.append("-?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))");
			reg.append("-?((0?[1-9])|([1-2][0-9])|(30)))|(0?2-?((0?[");
			reg.append("1-9])|(1[0-9])|(2[0-8]))))))");
			Pattern p = Pattern.compile(reg.toString());
			return p.matcher(date).matches();
		}

		/**
		 * 取得指定日期过 months 月后的日期 (当 months 为负数表示指定月之前);
		 * 
		 * @param date
		 *            日期 为null时表示当天
		 * @param months
		 *            相加(相减)的月数
		 */
		public static Date nextMonth(Date date, int months) {
			Calendar cal = Calendar.getInstance();
			if (date != null) {
				cal.setTime(date);
			}
			cal.add(Calendar.MONTH, months);
			return cal.getTime();
		}

		/**
		 * 取得指定日期过 day 天后的日期 (当 day 为负数表示指日期之前);
		 * 
		 * @param date
		 *            日期 为null时表示当天
		 * @param days
		 *            相加(相减)的天数
		 */
		public static Date nextDay(Date date, int days) {
			Calendar cal = Calendar.getInstance();
			if (date != null) {
				cal.setTime(date);
			}
			cal.add(Calendar.DAY_OF_YEAR, days);
			return cal.getTime();
		}

		/**
		 * 取得距离今天 day 日的日期
		 * 
		 * @param day
		 * @param format
		 * @return
		 */
		public static String nextDay(int day, String format) {
			Calendar cal = Calendar.getInstance();
			cal.setTime(new Date());
			cal.add(Calendar.DAY_OF_YEAR, day);
			return date2String(cal.getTime(), format);
		}

		/**
		 * 取得指定日期过 week 周后的日期 (当 week 为负数表示指定月之前)
		 * 
		 * @param date
		 *            日期 为null时表示当天
		 */
		public static Date nextWeek(Date date, int week) {
			Calendar cal = Calendar.getInstance();
			if (date != null) {
				cal.setTime(date);
			}
			cal.add(Calendar.WEEK_OF_MONTH, week);
			return cal.getTime();
		}

		/**
		 * 获取昨天的日期,返回的日期格式：yyyy-MM-dd
		 * 
		 * @return
		 */
		public static String befoDay() {
			return befoDay(LONG_DATE);
		}

		/**
		 * 根据时间类型获取昨天的日期
		 * 
		 * @param format
		 * @return
		 */
		public static String befoDay(String format) {
			return date2String(nextDay(new Date(), -1), format);
		}

		/**
		 * 获取明天的日期
		 * 
		 * @return
		 */
		public static String afterDay() {
			return date2String(nextDay(new Date(), 1),
					LONG_DATE);
		}

		/**
		 * 取得当前时间距离1900/1/1的天数
		 * 
		 * @return
		 */
		public static int getDayNum() {
			int daynum = 0;
			GregorianCalendar gd = new GregorianCalendar();
			Date dt = gd.getTime();
			GregorianCalendar gd1 = new GregorianCalendar(1900, 1, 1);
			Date dt1 = gd1.getTime();
			daynum = (int) ((dt.getTime() - dt1.getTime()) / (24 * 60 * 60 * 1000));
			return daynum;
		}

		/**
		 * getDayNum的逆方法(用于处理Excel取出的日期格式数据等)
		 * 
		 * @param day
		 * @return
		 */
		public static Date getDateByNum(int day) {
			GregorianCalendar gd = new GregorianCalendar(1900, 1, 1);
			Date date = gd.getTime();
			date = nextDay(date, day);
			return date;
		}

		/** 针对yyyy-MM-dd HH:mm:ss格式,显示yyyymmdd */
		public static String getYmdDateCN(String datestr) {
			if (datestr == null)
				return "";
			if (datestr.length() < 10)
				return "";
			StringBuffer buf = new StringBuffer();
			buf.append(datestr.substring(0, 4)).append(datestr.substring(5, 7))
					.append(datestr.substring(8, 10));
			return buf.toString();
		}

		/**
		 * 获取本月第一天
		 * 
		 * @param format
		 * @return
		 */
		public static String getFirstDayOfMonth(String format) {
			Calendar cal = Calendar.getInstance();
			cal.set(Calendar.DATE, 1);
			return date2String(cal.getTime(), format);
		}

		/**
		 * 获取本月最后一天
		 * 
		 * @param format
		 * @return
		 */
		public static String getLastDayOfMonth(String format) {
			Calendar cal = Calendar.getInstance();
			cal.set(Calendar.DATE, 1);
			cal.add(Calendar.MONTH, 1);
			cal.add(Calendar.DATE, -1);
			return date2String(cal.getTime(), format);
		}

		/**
		 * 得到某日期的起始TimeStamp，比如：2011-08-17 00:00:00
		 * 
		 * @param date
		 * @return
		 */
		public static Date getBeginTimeOfDate(Date date) {
			Calendar cal = Calendar.getInstance();
			Calendar ret = Calendar.getInstance();
			cal.setTime(date);
			ret.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal
					.get(Calendar.DATE), 0, 0, 0);
			return ret.getTime();
		}

		/**
		 * 得到某日期的最后一刻TimeStamp，比如：2011-08-17 23:59:59
		 * 
		 * @param date
		 * @return
		 */
		public static Date getEndTimeOfDate(Date date) {
			Calendar cal = Calendar.getInstance();
			Calendar ret = Calendar.getInstance();
			cal.setTime(date);
			ret.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal
					.get(Calendar.DATE), 23, 59, 59);
			return ret.getTime();
		}

		/**
		 * 得到该日期所在周的周一的凌晨
		 * @param date
		 * @return
		 */
		public static Date getBeginTimeOfWeek(Date date) {
			Calendar cal = Calendar.getInstance();
			cal.setTime(date);
			cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
			cal.set(Calendar.HOUR_OF_DAY, 0);
			cal.set(Calendar.MINUTE, 0);
			cal.set(Calendar.SECOND, 0);
			return cal.getTime();
		}

		/**
		 * 得到该日期所在周的周末的最后一刻
		 * @param date
		 * @return
		 */
		public static Date getEndTimeOfWeek(Date date) {
			Calendar cal = Calendar.getInstance();
			cal.setTime(date);
			cal.add(Calendar.WEEK_OF_MONTH, 1);
			cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
			cal.set(Calendar.HOUR_OF_DAY, 23);
			cal.set(Calendar.MINUTE, 59);
			cal.set(Calendar.SECOND, 59);
			return cal.getTime();
		}
		
		/**
		 * 得到该日期所在月的第一天的凌晨
		 * @param date
		 * @return
		 */
		public static Date getBeginTimeOfMonth(Date date) {
	        Calendar cal = Calendar.getInstance();
	        cal.setTime(date);
	        cal.set(Calendar.DAY_OF_MONTH, 1);
	        cal.set(Calendar.HOUR_OF_DAY, 0);
	        cal.set(Calendar.MINUTE,0);
	        cal.set(Calendar.SECOND,0);
	        return cal.getTime();
	    }

		/**
		 * 得到该日期所在月的最后一天的最后一刻
		 * @param date
		 * @return
		 */
		public static Date getEndTimeOfMonth(Date date) {
	        Calendar cal = Calendar.getInstance();
	        cal.setTime(date);
	        cal.add(Calendar.MONTH, 1);
	        cal.set(Calendar.DAY_OF_MONTH, 1);
	        cal.set(Calendar.HOUR_OF_DAY, 0);
	        cal.set(Calendar.MINUTE,0);
	        cal.set(Calendar.SECOND,0);
	        cal.set(Calendar.SECOND, -1);
	        return cal.getTime();
	    }
	/**
	 * 根据指定格式获取当前时间
	 * @author chenssy
	 * @date Dec 27, 2013
	 * @param format
	 * @return String
	 */
	public static String getCurrentTime(String format){
		SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		Date date = new Date();
		return sdf.format(date);
	}
	
	/**
	 * 获取当前时间，格式为：yyyy-MM-dd HH:mm:ss
	 * @author chenssy
	 * @date Dec 27, 2013
	 * @return String
	 */
	public static String getCurrentTime(){
		return getCurrentTime(DateFormatUtils.DATE_FORMAT2);
	}
	
	/**
	 * 获取指定格式的当前时间：为空时格式为yyyy-mm-dd HH:mm:ss
	 * @author chenssy
	 * @date Dec 30, 2013
	 * @param format
	 * @return Date
	 */
	public static Date getCurrentDate(String format){
		 SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		 String dateS = getCurrentTime(format);
		 Date date = null;
		 try {
			date = sdf.parse(dateS);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}
	
	/**
	 * 获取当前时间，格式为yyyy-MM-dd HH:mm:ss
	 * @author chenssy
	 * @date Dec 30, 2013
	 * @return Date
	 */
	public static Date getCurrentDate(){
		return getCurrentDate(DateFormatUtils.DATE_FORMAT2);
	}
	
	/**
	 * 给指定日期加入年份，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 30, 2013
	 * @param year 年份  正数相加、负数相减
	 * @param date 为空时，默认为当前时间
	 * @param format 默认格式为：yyyy-MM-dd HH:mm:ss
	 * @return String
	 */
	public static String addYearToDate(int year,Date date,String format){
		Calendar calender = getCalendar(date,format);
		SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		
		calender.add(Calendar.YEAR, year);
		
		return sdf.format(calender.getTime());
	}
	
	/**
	 * 给指定日期加入年份，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 30, 2013
	 * @param year 年份  正数相加、负数相减
	 * @param date 为空时，默认为当前时间
	 * @param format 默认格式为：yyyy-MM-dd HH:mm:ss
	 * @return String
	 */
	public static String addYearToDate(int year,String date,String format){
		Date newDate = new Date();
		if(null != date && !"".equals(date)){
			newDate = string2Date(date, format);
		}
		
		return addYearToDate(year, newDate, format);
	}
	
	/**
	 * 给指定日期增加月份 为空时默认当前时间
	 * @author chenssy
	 * @date Dec 30, 2013
	 * @param month  增加月份  正数相加、负数相减
	 * @param date 指定时间
	 * @param format 指定格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addMothToDate(int month,Date date,String format) {
		Calendar calender = getCalendar(date,format);
		SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		
		calender.add(Calendar.MONTH, month);
		
		return sdf.format(calender.getTime());
	}
	
	/**
	 * 给指定日期增加月份 为空时默认当前时间
	 * @author chenssy
	 * @date Dec 30, 2013
	 * @param month  增加月份  正数相加、负数相减
	 * @param date 指定时间
	 * @param format 指定格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addMothToDate(int month,String date,String format) {
		Date newDate = new Date();
		if(null != date && !"".equals(date)){
			newDate = string2Date(date, format);
		}
		
		return addMothToDate(month, newDate, format);
	}
	
	/**
	 * 给指定日期增加天数，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param day 增加天数 正数相加、负数相减
	 * @param date 指定日期
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addDayToDate(int day,Date date,String format) {
		Calendar calendar = getCalendar(date, format);
		SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		
		calendar.add(Calendar.DATE, day);
		
		return sdf.format(calendar.getTime());
	}
	
	/**
	 * 给指定日期增加天数，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param day 增加天数 正数相加、负数相减
	 * @param date 指定日期
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addDayToDate(int day,String date,String format) {
		Date newDate = new Date();
		if(null != date && !"".equals(date)){
			newDate = string2Date(date, format);
		}
		
		return addDayToDate(day, newDate, format);
	}
	
	/**
	 * 给指定日期增加小时，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param hour 增加小时  正数相加、负数相减
	 * @param date 指定日期
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addHourToDate(int hour,Date date,String format) {
		Calendar calendar = getCalendar(date, format);
		SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		
		calendar.add(Calendar.HOUR, hour);
		
		return sdf.format(calendar.getTime());
	}
	
	/**
	 * 给指定日期增加小时，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param hour 增加小时  正数相加、负数相减
	 * @param date 指定日期
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addHourToDate(int hour,String date,String format) {
		Date newDate = new Date();
		if(null != date && !"".equals(date)){
			newDate = string2Date(date, format);
		}
		
		return addHourToDate(hour, newDate, format);
	}
	
	/**
	 * 给指定的日期增加分钟，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param minute 增加分钟  正数相加、负数相减
	 * @param date 指定日期 
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addMinuteToDate(int minute,Date date,String format) {
		Calendar calendar = getCalendar(date, format);
		SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		
		calendar.add(Calendar.MINUTE, minute);
		
		return sdf.format(calendar.getTime());
	}
	
	/**
	 * 给指定的日期增加分钟，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param minute 增加分钟  正数相加、负数相减
	 * @param date 指定日期 
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addMinuteToDate(int minute,String date,String format){
		Date newDate = new Date();
		if(null != date && !"".equals(date)){
			newDate = string2Date(date, format);
		}
		
		return addMinuteToDate(minute, newDate, format);
	}
	
	/**
	 * 给指定日期增加秒，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param second 增加秒 正数相加、负数相减
	 * @param date 指定日期
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 */
	public static String addSecondToDate(int second,Date date,String format){
		Calendar calendar = getCalendar(date, format);
		SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
		
		calendar.add(Calendar.SECOND, second);
		
		return sdf.format(calendar.getTime());
	}
	
	/**
	 * 给指定日期增加秒，为空时默认当前时间
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param second 增加秒 正数相加、负数相减
	 * @param date 指定日期
	 * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
	 * @return String
	 * @throws Exception 
	 */
	public static String addSecondToDate(int second,String date,String format){
		Date newDate = new Date();
		if(null != date && !"".equals(date)){
			newDate = string2Date(date, format);
		}
		
		return addSecondToDate(second, newDate, format);
	}
	
	/**
	 * 获取指定格式指定时间的日历
	 * @author chenssy
	 * @date Dec 30, 2013
	 * @param date 时间 
	 * @param format 格式
	 * @return Calendar
	 */
	public static Calendar getCalendar(Date date,String format){
		if(date == null){
			date = getCurrentDate(format);
		}
		
		Calendar calender = Calendar.getInstance();
		calender.setTime(date);
		
		return calender;
	}
	
	/**
	 * 字符串转换为日期，日期格式为
	 * 
	 * @author : chenssy
	 * @date : 2016年5月31日 下午5:20:22
	 *
	 * @param value
	 * @return
	 */
	public static Date string2Date(String value){
		if(value == null || "".equals(value)){
			return null;
		}
		
		SimpleDateFormat sdf = DateFormatUtils.getFormat(DateFormatUtils.DATE_FORMAT2);
		Date date = null;
		
		try {
			value = DateFormatUtils.formatDate(value, DateFormatUtils.DATE_FORMAT2);
			date = sdf.parse(value);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return date;
	}
	
	
	/**
	 * 日期转换为字符串
	 * 
	 * @author : chenssy
	 * @date : 2016年5月31日 下午5:21:38
	 *
	 * @param value
	 * @return
	 */
	public static String date2String(Date value){
		if(value == null){
			return null;
		}
		
		SimpleDateFormat sdf = DateFormatUtils.getFormat(DateFormatUtils.DATE_FORMAT2);
		return sdf.format(value);
	}
	
	/**
	 * 获取指定日期的年份
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentYear(Date value){
		String date = date2String(value, DateFormatUtils.DATE_YEAR);
		return Integer.valueOf(date);
	}
	
	/**
	 * 获取指定日期的年份
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentYear(String value) {
		Date date = string2Date(value, DateFormatUtils.DATE_YEAR);
		Calendar calendar = getCalendar(date, DateFormatUtils.DATE_YEAR);
		return calendar.get(Calendar.YEAR);
	}
	
	/**
	 * 获取指定日期的月份
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentMonth(Date value){
		String date = date2String(value, DateFormatUtils.DATE_MONTH);
		return Integer.valueOf(date);
	}
	
	/**
	 * 获取指定日期的月份
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentMonth(String value) {
		Date date = string2Date(value, DateFormatUtils.DATE_MONTH);
		Calendar calendar = getCalendar(date, DateFormatUtils.DATE_MONTH);
		
		return calendar.get(Calendar.MONTH);
	}
	
	/**
	 * 获取指定日期的天份
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentDay(Date value){
		String date = date2String(value, DateFormatUtils.DATE_DAY);
		return Integer.valueOf(date);
	}
	
	/**
	 * 获取指定日期的天份
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentDay(String value){
		Date date = string2Date(value, DateFormatUtils.DATE_DAY);
		Calendar calendar = getCalendar(date, DateFormatUtils.DATE_DAY);
		
		return calendar.get(Calendar.DATE);
	}
	
	/**
	 * 获取当前日期为星期几
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return String
	 */
	public static String getCurrentWeek(Date value) {
		Calendar calendar = getCalendar(value, DateFormatUtils.DATE_FORMAT1);
		int weekIndex = calendar.get(Calendar.DAY_OF_WEEK) - 1 < 0 ? 0 : calendar.get(Calendar.DAY_OF_WEEK) - 1;
		
		return weeks[weekIndex];
	}
	
	/**
	 * 获取当前日期为星期几
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return String
	 */
	public static String getCurrentWeek(String value) {
		Date date = string2Date(value, DateFormatUtils.DATE_FORMAT1);
		return getCurrentWeek(date);
	}
	
	/**
	 * 获取指定日期的小时
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentHour(Date value){
		String date = date2String(value, DateFormatUtils.DATE_HOUR);
		return Integer.valueOf(date);
	}
	
	/**
	 * 获取指定日期的小时
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return
	 * @return int
	 */
	public static int getCurrentHour(String value) {
		Date date = string2Date(value, DateFormatUtils.DATE_HOUR);
		Calendar calendar = getCalendar(date, DateFormatUtils.DATE_HOUR);
		
		return calendar.get(Calendar.DATE);
	}
	
	/**
	 * 获取指定日期的分钟
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentMinute(Date value){
		String date = date2String(value, DateFormatUtils.DATE_MINUTE);
		return Integer.valueOf(date);
	}
	
	/**
	 * 获取指定日期的分钟
	 * @author chenssy
	 * @date Dec 31, 2013
	 * @param value 日期
	 * @return int
	 */
	public static int getCurrentMinute(String value){
		Date date = string2Date(value, DateFormatUtils.DATE_MINUTE);
		Calendar calendar = getCalendar(date, DateFormatUtils.DATE_MINUTE);
		
		return calendar.get(Calendar.MINUTE);
	}
	
	/**  
	 * 比较两个日期相隔多少天(月、年) <br>
	 * 例：<br>
	 * &nbsp;compareDate("2009-09-12", null, 0);//比较天 <br>
     * &nbsp;compareDate("2009-09-12", null, 1);//比较月 <br> 
     * &nbsp;compareDate("2009-09-12", null, 2);//比较年 <br>
     * 
	 * @author chenssy
	 * @date Dec 31, 2013 
     * @param startDay 需要比较的时间 不能为空(null),需要正确的日期格式 ,如：2009-09-12   
     * @param endDay 被比较的时间  为空(null)则为当前时间    
     * @param stype 返回值类型   0为多少天，1为多少个月，2为多少年    
     * @return int
     */    
    public static int compareDate(String startDay,String endDay,int stype) {     
        int n = 0;     
        startDay = DateFormatUtils.formatDate(startDay, "yyyy-MM-dd");
        endDay = DateFormatUtils.formatDate(endDay, "yyyy-MM-dd");
        
        String formatStyle = "yyyy-MM-dd";
        if(1 == stype){
        	formatStyle = "yyyy-MM";
        }else if(2 == stype){
        	formatStyle = "yyyy";
        }   
             
        endDay = endDay==null ? getCurrentTime("yyyy-MM-dd") : endDay;     
             
        DateFormat df = new SimpleDateFormat(formatStyle);     
        Calendar c1 = Calendar.getInstance();     
        Calendar c2 = Calendar.getInstance();     
        try {     
            c1.setTime(df.parse(startDay));     
            c2.setTime(df.parse(endDay));   
        } catch (Exception e) {    
        	e.printStackTrace();
        }     
        while (!c1.after(c2)) {                   // 循环对比，直到相等，n 就是所要的结果     
            n++;     
            if(stype==1){     
                c1.add(Calendar.MONTH, 1);          // 比较月份，月份+1     
            }     
            else{     
                c1.add(Calendar.DATE, 1);           // 比较天数，日期+1     
            }     
        }     
        n = n-1;     
        if(stype==2){     
            n = (int)n/365;     
        }        
        return n;     
    }   
    
    /**
     * 比较两个时间相差多少小时(分钟、秒)
     * @author chenssy
     * @date Jan 2, 2014
     * @param startTime 需要比较的时间 不能为空，且必须符合正确格式：2012-12-12 12:12:
     * @param endTime 需要被比较的时间 若为空则默认当前时间
     * @param type 1：小时   2：分钟   3：秒
     * @return int
     */
    public static int compareTime(String startTime , String endTime , int type) {
    	//endTime是否为空，为空默认当前时间
    	if(endTime == null || "".equals(endTime)){
    		endTime = getCurrentTime();
    	}
    	
    	SimpleDateFormat sdf = DateFormatUtils.getFormat("");
    	int value = 0;
    	try {
			Date begin = sdf.parse(startTime);
			Date end = sdf.parse(endTime);
			long between = (end.getTime() - begin.getTime()) / 1000;  //除以1000转换成豪秒
			if(type == 1){   //小时
				value = (int) (between % (24 * 36000) / 3600);
			}
			else if(type == 2){
				value = (int) (between % 3600 / 60);
			}
			else if(type == 3){
				value = (int) (between % 60 / 60);
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
    	return value;
    }
    
    /**
     * 比较两个日期的大小。<br>
     * 若date1 > date2 则返回 1<br>
     * 若date1 = date2 则返回 0<br>
     * 若date1 < date2 则返回-1
     * @autor:chenssy
     * @date:2014年9月9日
     *
     * @param date1  
     * @param date2
     * @param format  待转换的格式
     * @return 比较结果
     */
    public static int compare(String date1, String date2,String format) {
        DateFormat df = DateFormatUtils.getFormat(format);
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            if (dt1.getTime() > dt2.getTime()) {
                return 1;
            } else if (dt1.getTime() < dt2.getTime()) {
                return -1;
            } else {
                return 0;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
    }
    
    /**
     * 获取指定月份的第一天 
     * 
     * @author : chenssy
     * @date : 2016年5月31日 下午5:31:10
     *
     * @param date
     * @return
     */
    public static String getMonthFirstDate(String date){
    	date = DateFormatUtils.formatDate(date);
		return DateFormatUtils.formatDate(date, "yyyy-MM") + "-01";
    }
    
    /**
     * 获取指定月份的最后一天
     * 
     * @author : chenssy
     * @date : 2016年5月31日 下午5:32:09
     *
     * @param date
     * @return
     */
	public static String getMonthLastDate(String date) {
		Date strDate = DateExtUtils.string2Date(getMonthFirstDate(date));
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(strDate);
		calendar.add(Calendar.MONTH, 1);
		calendar.add(Calendar.DAY_OF_YEAR, -1);
		return DateFormatUtils.formatDate(calendar.getTime());
	}
	
	/**
	 * 获取所在星期的第一天
	 * 
	 * @author : chenssy
	 * @date : 2016年6月1日 下午12:38:53
	 *
	 * @param date
	 * @return
	 */
	@SuppressWarnings("static-access")
	public static Date getWeekFirstDate(Date date) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		int today = now.get(Calendar.DAY_OF_WEEK);
		int first_day_of_week = now.get(Calendar.DATE) + 2 - today; // 星期一
		now.set(now.DATE, first_day_of_week);
		return now.getTime();
	}
	
	/**
	 * 获取所在星期的最后一天
	 * 
	 * @author : chenssy
	 * @date : 2016年6月1日 下午12:40:31
	 *
	 * @param date
	 * @return
	 */
	@SuppressWarnings("static-access")
	public static Date geWeektLastDate(Date date) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		int today = now.get(Calendar.DAY_OF_WEEK);
		int first_day_of_week = now.get(Calendar.DATE) + 2 - today; // 星期一
		int last_day_of_week = first_day_of_week + 6; // 星期日
		now.set(now.DATE, last_day_of_week);
		return now.getTime();
	}
	
	
	/**
     * String转换为TimeStamp
     * @param value
     *              待转换的String，格式必须为 yyyy-mm-dd hh:mm:ss[.f...] 这样的格式，中括号表示可选，否则报错
     * @return java.sql.Timestamp
     *
     * @author chenssy
     * @date 2016-09-24
     * @since v1.0.0
     */
    public static Timestamp string2Timestamp(String value){
        if(value == null && !"".equals(value.trim())){
            return null;
        }
    	Timestamp ts = new Timestamp(System.currentTimeMillis());
    	ts = Timestamp.valueOf(value);
    	return ts;
    }

    /**
     * 将Timestamp 转换为String类型，format为null则使用默认格式 yyyy-MM-dd HH:mm:ss
     *
     * @param value
     *              待转换的Timestamp
     * @param format
     *              String的格式
     * @return java.lang.String
     *
     * @author chenssy
     * @date 2016-09-24
     * @since v1.0.0
     */
    public static String timestamp2String(Timestamp value,String format){
    	if(null == value){
    		return "";
    	}
    	SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
    	
    	return sdf.format(value);
    }

    /**
     * Date转换为Timestamp
     *
     * @param date
     *              待转换的Date
     * @return java.sql.Timestamp
     *
     * @author chenssy
     * @date 2016-09-24
     * @since v1.0.0
     */
    public static Timestamp date2Timestamp(Date date){
        if(date == null){
            return null;
        }
        return new Timestamp(date.getTime());
    }

    /**
     * Timestamp转换为Date
     *
     * @param time
     *              待转换的Timestamp
     * @return java.util.Date
     *
     * @author chenssy
     * @date 2016-09-24
     * @since v1.0.0
     */
    public static Date timestamp2Date(Timestamp time){
        return time == null ? null : time;
    }
}
